home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / video / xevil-1.000 / xevil-1 / coord.C < prev    next >
C/C++ Source or Header  |  1995-07-10  |  7KB  |  458 lines
  1. // "coord.C"
  2. // TAG: CO
  3.  
  4. /*    Copyright (C) 1994  Steve Hardt
  5.  
  6.     This program is free software; you can redistribute it and/or modify
  7.     it under the terms of the GNU General Public License as published by
  8.     the Free Software Foundation; either version 1, or (at your option)
  9.     any later version.
  10.  
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  15.  
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  
  20.     Steve Hardt 
  21.     hardts@athena.mit.edu hardts@media.mit.edu
  22.     hardts@r4002.3dem.bioch.bcm.tmc.edu
  23.     2043 McClendon
  24.     Houston, TX 77030
  25. */
  26.  
  27. #ifndef NO_PRAGMAS
  28. #pragma implementation "coord.h"
  29. #endif
  30.  
  31.  
  32. // Include Files
  33. #include "utils.h"
  34. #include "coord.h"
  35.  
  36.  
  37.  
  38. // Functions.
  39. void Stats::add_death(time_t birthTime)
  40. {
  41.   time_t lifespan = time(NULL) - birthTime;
  42.  
  43.   if (deaths > 0)
  44.     aveLifespan = (aveLifespan * deaths + lifespan) / (deaths + 1);
  45.   else
  46.     aveLifespan = lifespan;
  47.   
  48.   deaths++;
  49. }
  50.  
  51.  
  52.  
  53. int Pos::distance(const Pos &p) const
  54. {
  55.   Size diff = *this - p;
  56.   assert (diff.abs_2() >= 0);
  57.   
  58.   return (int)sqrt(diff.width * diff.width + diff.height * diff.height);
  59. }
  60.  
  61.  
  62.  
  63. int Pos::distance_2(const Pos &p) const
  64. {
  65.   Size diff = *this - p;
  66.   
  67.   return diff.width * diff.width + diff.height * diff.height;
  68. }
  69.  
  70.  
  71.  
  72. Dir Size::get_dir()
  73. {
  74.   if (!width && !height)
  75.     return CO_air;
  76.  
  77.   if (height < 0.5 * width)
  78.     if (height > -2 * width)
  79.       if (height < -0.5 * width)
  80.     return CO_UP_R;
  81.       else
  82.     return CO_R;
  83.     else
  84.       if (height < 2 * width)
  85.     return CO_UP;
  86.       else
  87.     return CO_UP_L;
  88.   else
  89.     if (height < -2 * width)
  90.       if (height < -0.5 * width)
  91.     return CO_L;
  92.       else
  93.     return CO_DN_L;
  94.     else
  95.       if (height < 2 * width)
  96.     return CO_DN_R;
  97.       else
  98.     return CO_DN;
  99. }
  100.  
  101.  
  102.  
  103. void Size::get_dirs_4(Dir &d1,Dir &d2)
  104. {
  105.   if (!width && !height)
  106.     {
  107.       d1 = d2 = CO_air;
  108.       return;
  109.     }
  110.  
  111.   if (width)
  112.     d1 = (width > 0) ? CO_R : CO_L;
  113.   
  114.   if (height)
  115.     d2 = (height > 0) ? CO_DN : CO_UP;
  116.   else
  117.     d2 = d1;
  118.  
  119.   if (!width)
  120.     d1 = d2;
  121. }
  122.  
  123.  
  124.  
  125. float Size::cross(const Vel &vel)
  126. {
  127.   return width * vel.dy - height * vel.dx;
  128. }
  129.  
  130.  
  131.  
  132. Boolean Box::overlap(const Loc &l)
  133. {
  134.   if ((l.c >= loc.c) && (l.c < loc.c + dim.colMax) &&
  135.       (l.r >= loc.r) && (l.r < loc.r + dim.rowMax))
  136.     return True;
  137.   else
  138.     return False;
  139. }
  140.  
  141.  
  142.  
  143. Vel Vel::shrink(float k) const
  144. {
  145.   Vel ret = *this;
  146.  
  147.   if (ret.dx > k)
  148.     ret.dx -= k;
  149.   else if (ret.dx < -k)
  150.     ret.dx += k;
  151.   else
  152.     ret.dx = 0;
  153.  
  154.   if (ret.dy > k)
  155.     ret.dy -= k;
  156.   else if (ret.dy < -k)
  157.     ret.dy += k;
  158.   else
  159.     ret.dy = 0;
  160.  
  161.   return ret;
  162. }
  163.  
  164.  
  165.  
  166. void Vel::damp(float k)
  167. {
  168.   if (dx > k)
  169.     dx -= k;
  170.   else if (dx < -k)
  171.     dx += k;
  172.   else
  173.     dx = 0;
  174.  
  175.   if (dy > k)
  176.     dy -= k;
  177.   else if (dy < -k)
  178.     dy += k;
  179.   else
  180.     dy = 0;
  181. }
  182.  
  183.  
  184.  
  185. Boolean Vel::is_zero() const
  186. {
  187.   Boolean ret;
  188.   if ((dx == 0) && (dy == 0))
  189.     ret = True;
  190.   else
  191.     ret = False;
  192.   return ret;
  193. }
  194.  
  195.  
  196.  
  197. Dir Vel::get_dir() const
  198. {
  199.   if (!dx && !dy)
  200.     return CO_air;
  201.  
  202.   if (dy < 0.5 * dx)
  203.     if (dy > -2 * dx)
  204.       if (dy < -0.5 * dx)
  205.     return CO_UP_R;
  206.       else
  207.     return CO_R;
  208.     else
  209.       if (dy < 2 * dx)
  210.     return CO_UP;
  211.       else
  212.     return CO_UP_L;
  213.   else
  214.     if (dy < -2 * dx)
  215.       if (dy < -0.5 * dx)
  216.     return CO_L;
  217.       else
  218.     return CO_DN_L;
  219.     else
  220.       if (dy < 2 * dx)
  221.     return CO_DN_R;
  222.       else
  223.     return CO_DN;
  224. }
  225.  
  226.  
  227.  
  228. void Vel::limit(float k)
  229. {
  230.   assert (k >= 0);
  231.  
  232.   if (dx > k)
  233.     dx = k;
  234.   if (dx < -k)
  235.     dx = -k;
  236.   if (dy > k)
  237.     dy = k;
  238.   if (dy < -k)
  239.     dy = -k;
  240. }
  241.  
  242.  
  243.  
  244. void Vel::get_dirs_4(Dir in[4],Dir out[4],int &inNum,int &outNum)
  245. {
  246.   inNum = 0;
  247.   outNum = 0;
  248.  
  249.   if (dx > 0)
  250.     {
  251.       in[inNum] = CO_R;
  252.       inNum++;
  253.     }
  254.   else
  255.     {
  256.       out[outNum] = CO_R;
  257.       outNum++;
  258.     }
  259.  
  260.   if (dy > 0)
  261.     {
  262.       in[inNum] = CO_DN;
  263.       inNum++;
  264.     }
  265.   else
  266.     {
  267.       out[outNum] = CO_DN;
  268.       outNum++;
  269.     }
  270.  
  271.   if (dx < 0)
  272.     {
  273.       in[inNum] = CO_L;
  274.       inNum++;
  275.     }
  276.   else
  277.     {
  278.       out[outNum] = CO_L;
  279.       outNum++;
  280.     }
  281.  
  282.   if (dy < 0)
  283.     {
  284.       in[inNum] = CO_UP;
  285.       inNum++;
  286.     }
  287.   else
  288.     {
  289.       out[outNum] = CO_UP;
  290.       outNum++;
  291.     }
  292.  
  293.   assert(inNum + outNum == 4);
  294. }
  295.  
  296.  
  297.  
  298. Boolean operator == (const Loc &l1, const Loc &l2)
  299. {
  300.   return l1.r == l2.r && l1.c == l2.c;
  301. }
  302.  
  303.  
  304.  
  305. Boolean operator == (const Pos &p1, const Pos &p2)
  306. {
  307.   return p1.x == p2.x && p1.y == p2.y;
  308. }
  309.  
  310.  
  311.  
  312. Boolean operator == (const Vel &v1, const Vel &v2)
  313. {
  314.   return v1.dx == v2.dx && v1.dy == v2.dy;
  315. }
  316.  
  317.  
  318.  
  319. Boolean operator == (const Size &s1, const Size &s2)
  320. {
  321.   if ((s1.width == s2.width) && (s1.height == s2.height))
  322.     return True;
  323.   else
  324.     return False;
  325. }
  326.  
  327.  
  328.  
  329. Boolean operator == (const GLoc &g1,const GLoc &g2)
  330. {
  331.   return (g1.horiz == g2.horiz) && (g1.vert == g2.vert);
  332. }
  333.  
  334.  
  335.  
  336. Boolean operator != (const GLoc &g1,const GLoc &g2)
  337. {
  338.   return (g1.horiz != g2.horiz) || (g1.vert != g2.vert);
  339. }
  340.  
  341.  
  342.  
  343.  Pos operator + (const Pos &pos,const Size &size)
  344. {
  345.   Pos ret;
  346.   ret.x = pos.x + size.width;
  347.   ret.y = pos.y + size.height;
  348.   return ret;
  349. }
  350.  
  351.  
  352.  
  353.  Pos operator - (const Pos &pos,const Size &size)
  354. {
  355.   Pos ret;
  356.   ret.x = pos.x - size.width;
  357.   ret.y = pos.y - size.height;
  358.   return ret;
  359. }
  360.  
  361.  
  362.  
  363. Size operator - (const Pos &p1,const Pos &p2)
  364. {
  365.   Size ret;
  366.   ret.width = p1.x - p2.x;
  367.   ret.height = p1.y - p2.y;
  368.   return ret;
  369. }
  370.  
  371.  
  372.  
  373. Pos operator + (const Pos &pos, const Vel &vel)
  374. {
  375.   Pos ret;
  376.   
  377.   /* We want it to round towards zero so that it does the same thing for 
  378.      something going to the right as to the left. */
  379.   ret.x = pos.x + (int)vel.dx;
  380.   ret.y = pos.y + (int)vel.dy;
  381.   /*  ret.x = pos.x + (int)trunc(vel.dx);
  382.       ret.y = pos.y + (int)trunc(vel.dy);
  383.       */
  384.   return ret;
  385. }
  386.  
  387.      
  388.  
  389. Size operator * (float k,const Size &size)
  390. {
  391.   Size ret;
  392.   ret.width = (int)floor(k * size.width);
  393.   ret.height = (int)floor(k * size.height);
  394.   return ret;
  395. }
  396.  
  397.  
  398.  
  399. Vel operator + (const Vel &v1,const Vel &v2)
  400. {
  401.   Vel ret(v1.dx + v2.dx,v1.dy + v2.dy);
  402.   return ret;
  403. }
  404.  
  405.  
  406.  
  407. Vel operator + (const Vel &vel, const Acc &acc)
  408. {
  409.   Vel ret(vel.dx + acc.ddx,vel.dy + acc.ddy);
  410.   return ret;
  411. }
  412.  
  413.      
  414.  
  415. Vel operator * (float k,const Vel &vel)
  416. {
  417.   Vel ret(k * vel.dx, k * vel.dy);
  418.   return ret;
  419. }
  420.  
  421.  
  422.  
  423. Vel operator / (float k,const Vel &vel)
  424. {
  425.   Vel ret(k / vel.dx, k / vel.dy);
  426.   return ret;
  427. }
  428.  
  429.  
  430.  
  431. Vel operator + (float k,const Vel &vel)
  432. {
  433.   Vel ret(k + vel.dx,k + vel.dy);
  434.   return ret;
  435. }
  436.  
  437.  
  438.  
  439. Acc operator * (int k,const Acc &acc)
  440. {
  441.   Acc ret;
  442.   ret.ddx = k * acc.ddx;
  443.   ret.ddy = k * acc.ddy;
  444.   return ret;
  445. }
  446.  
  447.  
  448.  
  449. Dir Coord::dir_opposite(Dir dir)
  450. {
  451.   if (dir == CO_air)
  452.     return CO_air;
  453.  
  454.   assert(dir >= CO_R && dir < CO_DIR_MAX);
  455.  
  456.   return ((dir - CO_R + CO_DIR_PURE / 2) % CO_DIR_PURE) + CO_R;
  457. }
  458.